//The MIT License
//
//Copyright (c) <2011> <GEPAR - Grupo de Ensino e Pesquisa em Agroinformática e Rastreabilidade>
//
//Permission is hereby granted, free of charge, to any person obtaining a copy
//of this software and associated documentation files (the "Software"), to deal
//in the Software without restriction, including without limitation the rights
//to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
//copies of the Software, and to permit persons to whom the Software is
//furnished to do so, subject to the following conditions:
//
//The above copyright notice and this permission notice shall be included in
//all copies or substantial portions of the Software.
//
//THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
//IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
//FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
//AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
//LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
//OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
//THE SOFTWARE.

package core;

import java.sql.*;

/**
 * Classe responsável pela criação do banco de dados local (Java DB), de suas tabelas,
 * de popular as tabelas com dados padrão e, também, de realizar conexão com o banco de
 * dados.
 */
public class BancoDadosLocal
{

    /**
     * Driver para conexão com o banco; neste caso, usaremos o driver para conexão a banco de dados embarcado.
     */
    private final String driver = "org.apache.derby.jdbc.EmbeddedDriver";

    /**
     * Nome do banco de dados.
     */
    private final String nomeBD = "hermesdesktop";

    /**
     * Url para conexão ao banco.
     */
    private final String urlConexao = "jdbc:derby:" + nomeBD + ";create=true";

    /**
     * Objeto que provê uma conexão ativa com o banco de dados.
     */
    private Connection conexao;

    /**
     * Construtor vazio para implementação do padrão Singleton.
     */
    private BancoDadosLocal() {};

    /**
     * Classe interna para implementação do padrão Singleton.
     */
    private static class SingletonHolder
    {
        public static final BancoDadosLocal instancia = new BancoDadosLocal();
    }

    /**
     * Método que retorna o único objeto existente da classe BancoDadosLocal.
     * @return O único objeto existente da classe BancoDadosLocal.
     */
    public static BancoDadosLocal getInstancia()
    {
        return SingletonHolder.instancia;
    }

    public Connection getConexao()
    {
        return conexao;
    }

    /**
     * Método responsável pela criação do banco de dados local (Java DB) e de suas tabelas (já populadas
     * com dados iniciais). Também cria uma conexão com o banco de dados.
     */
    public void inicializar() throws Exception
    {
        try
        {
            Class.forName(driver);

        } catch (Exception e)
        {
            // a variável CLASSPATH não está configurada corretamente; não foi possível
            // carregar o driver
            throw e;
        }

        try
        {
            // cria o banco (se necessário) e faz a conexão
            conexao = DriverManager.getConnection(urlConexao);

            // criação (se necessário) das tabelas; além disso, são populadas com dados iniciais
            this.tblProdutos();
            this.tblEntrepostos();
            this.tblClassificacoes();
            this.tblTiposCaixa();
            this.tblQtdesCaixa();
            this.tblResponsaveisCol();
            this.tblTabulacoesPen();
            this.tblPrecos();
            this.tblEstatisticas();
            
        } catch (Exception e)
        {
            // ocorreu algum erro na criação/população do banco/tabelas
            throw e;
        }
    }

    /**
     * Cria (se necessário) a tabela produtos. Caso ela não exista, além de ser criada é populada
     * com seus dados iniciais.
     */
    private void tblProdutos() throws Exception
    {
        Statement sentencaSQL = conexao.createStatement();

        try
        {
            String sqlTblExiste = "UPDATE produtos SET " +
                    "id = 0, nome = 'teste', status = 'a' " +
                    "WHERE id = -1";

            sentencaSQL.execute(sqlTblExiste);

        } catch (Exception e)
        {
            SQLException sqle;

            try
            {
                sqle = (SQLException)e;
            }
            catch (Exception e2)
            {
                throw e2;
            }

            String erro = sqle.getSQLState();

            if (erro.equals("42X05"))
            {
                // a tabela não existe; por isso, a criamos
                String sqlCriarTblProdutos = "CREATE TABLE produtos" +
                "(" +
                "id INT NOT NULL, " +
                "nome VARCHAR(50) NOT NULL, " +
                "status CHAR NOT NULL, " +
                "PRIMARY KEY(id)" +
                ")";

                try
                {
                    sentencaSQL.execute(sqlCriarTblProdutos);
                    sentencaSQL.close();
                    
                } catch (Exception e3)
                {
                    throw e3;
                }

                // populamos a tabela de produtos com os valores padrão
                String sqlPopularTblProdutos = "INSERT INTO produtos(id, nome, status) " +
                        "VALUES(?, ?, ?)";

                try
                {
                    PreparedStatement prepSentSQL = conexao.prepareStatement(sqlPopularTblProdutos);

                    prepSentSQL.setInt(1, 1);
                    prepSentSQL.setString(2, "Abobrinha Italiana");
                    prepSentSQL.setString(3, "a");
                    prepSentSQL.execute();
                    prepSentSQL.setInt(1, 2);
                    prepSentSQL.setString(2, "Acelga");
                    prepSentSQL.execute();
                    prepSentSQL.setInt(1, 3);
                    prepSentSQL.setString(2, "Alface Americana");
                    prepSentSQL.execute();
                    prepSentSQL.setInt(1, 4);
                    prepSentSQL.setString(2, "Alface Crespa");
                    prepSentSQL.execute();
                    prepSentSQL.setInt(1, 5);
                    prepSentSQL.setString(2, "Alface Lisa");
                    prepSentSQL.execute();
                    prepSentSQL.setInt(1, 6);
                    prepSentSQL.setString(2, "Brócolos");
                    prepSentSQL.execute();
                    prepSentSQL.setInt(1, 7);
                    prepSentSQL.setString(2, "Brócolos Japonês");
                    prepSentSQL.execute();
                    prepSentSQL.setInt(1, 8);
                    prepSentSQL.setString(2, "Cenoura");
                    prepSentSQL.execute();
                    prepSentSQL.setInt(1, 9);
                    prepSentSQL.setString(2, "Chuchu");
                    prepSentSQL.execute();
                    prepSentSQL.setInt(1, 10);
                    prepSentSQL.setString(2, "Couve Flor");
                    prepSentSQL.execute();
                    prepSentSQL.setInt(1, 11);
                    prepSentSQL.setString(2, "Repolho Roxo");
                    prepSentSQL.execute();
                    prepSentSQL.setInt(1, 12);
                    prepSentSQL.setString(2, "Repolho Verde");
                    prepSentSQL.execute();
                    prepSentSQL.setInt(1, 13);
                    prepSentSQL.setString(2, "Vagem Macarrão");
                    prepSentSQL.execute();
                    prepSentSQL.close();
                    
                } catch (Exception e3)
                {
                    throw e3;
                }
            }
        }
        // se não ocorrer exceção, a tabela já existe e nada fazemos
    }

    /**
     * Cria (se necessário) a tabela entrepostos. Caso ela não exista, além de ser criada é populada
     * com seus dados iniciais.
     */
    private void tblEntrepostos() throws Exception
    {
        Statement sentencaSQL = conexao.createStatement();

        try
        {
            String sqlTblExiste = "UPDATE entrepostos SET " +
                    "id = 0, nome = 'teste', status = 'a' " +
                    "WHERE id = -1";

            sentencaSQL.execute(sqlTblExiste);

        } catch (Exception e)
        {
            SQLException sqle;

            try
            {
                sqle = (SQLException)e;
            }
            catch (Exception e2)
            {
                throw e2;
            }

            String erro = sqle.getSQLState();

            if (erro.equals("42X05"))
            {
                // a tabela não existe; por isso, a criamos
                String sqlCriarTblEntrepostos = "CREATE TABLE entrepostos" +
                "(" +
                "id INT NOT NULL, " +
                "nome VARCHAR(50) NOT NULL, " +
                "status CHAR NOT NULL, " +
                "PRIMARY KEY(id)" +
                ")";

                try
                {
                    sentencaSQL.execute(sqlCriarTblEntrepostos);
                    sentencaSQL.close();

                } catch (Exception e3)
                {
                    throw e3;
                }

                // populamos a tabela de entrepostos com os valores padrão
                String sqlPopularTblEntrepostos = "INSERT INTO entrepostos(id, nome, status) " +
                        "VALUES(?, ?, ?)";

                try
                {
                    PreparedStatement prepSentSQL = conexao.prepareStatement(sqlPopularTblEntrepostos);

                    prepSentSQL.setInt(1, 1);
                    prepSentSQL.setString(2, "Ceagesp");
                    prepSentSQL.setString(3, "a");
                    prepSentSQL.execute();
                    prepSentSQL.setInt(1, 2);
                    prepSentSQL.setString(2, "MP de Mogi das Cruzes");
                    prepSentSQL.execute();
                    prepSentSQL.close();

                } catch (Exception e3)
                {
                    throw e3;
                }
            }
        }
        // se não ocorrer exceção, a tabela já existe e nada fazemos
    }

    /**
     * Cria (se necessário) a tabela classificacoes. Caso ela não exista, além de ser criada é populada
     * com seus dados iniciais.
     */
    private void tblClassificacoes() throws Exception
    {
        Statement sentencaSQL = conexao.createStatement();

        try
        {
            String sqlTblExiste = "UPDATE classificacoes SET " +
                    "id = 0, nome = 'teste', status = 'a' " +
                    "WHERE id = -1";

            sentencaSQL.execute(sqlTblExiste);

        } catch (Exception e)
        {
            SQLException sqle;

            try
            {
                sqle = (SQLException)e;
            }
            catch (Exception e2)
            {
                throw e2;
            }

            String erro = sqle.getSQLState();

            if (erro.equals("42X05"))
            {
                // a tabela não existe; por isso, a criamos
                String sqlCriarTblEntrepostos = "CREATE TABLE classificacoes" +
                "(" +
                "id INT NOT NULL, " +
                "nome VARCHAR(50) NOT NULL, " +
                "status CHAR NOT NULL, " +
                "PRIMARY KEY(id)" +
                ")";

                try
                {
                    sentencaSQL.execute(sqlCriarTblEntrepostos);
                    sentencaSQL.close();

                } catch (Exception e3)
                {
                    throw e3;
                }

                // populamos a tabela de classificacoes com os valores padrão
                String sqlPopularTblEntrepostos = "INSERT INTO classificacoes(id, nome, status) " +
                        "VALUES(?, ?, ?)";

                try
                {
                    PreparedStatement prepSentSQL = conexao.prepareStatement(sqlPopularTblEntrepostos);

                    prepSentSQL.setInt(1, 1);
                    prepSentSQL.setString(2, "A");
                    prepSentSQL.setString(3, "a");
                    prepSentSQL.execute();
                    prepSentSQL.setInt(1, 2);
                    prepSentSQL.setString(2, "AA");
                    prepSentSQL.execute();
                    prepSentSQL.setInt(1, 3);
                    prepSentSQL.setString(2, "Extra");
                    prepSentSQL.execute();
                    prepSentSQL.close();

                } catch (Exception e3)
                {
                    throw e3;
                }
            }
        }
        // se não ocorrer exceção, a tabela já existe e nada fazemos
    }

    /**
     * Cria (se necessário) a tabela tipos_caixa. Caso ela não exista, além de ser criada é populada
     * com seus dados iniciais.
     */
    private void tblTiposCaixa() throws Exception
    {
        Statement sentencaSQL = conexao.createStatement();

        try
        {
            String sqlTblExiste = "UPDATE tipos_caixa SET " +
                    "id = 0, nome = 'teste', status = 'a' " +
                    "WHERE id = -1";

            sentencaSQL.execute(sqlTblExiste);

        } catch (Exception e)
        {
            SQLException sqle;

            try
            {
                sqle = (SQLException)e;
            }
            catch (Exception e2)
            {
                throw e2;
            }

            String erro = sqle.getSQLState();

            if (erro.equals("42X05"))
            {
                // a tabela não existe; por isso, a criamos
                String sqlCriarTblTiposCaixa = "CREATE TABLE tipos_caixa" +
                "(" +
                "id INT NOT NULL, " +
                "nome VARCHAR(50) NOT NULL, " +
                "status CHAR NOT NULL, " +
                "PRIMARY KEY(id)" +
                ")";

                try
                {
                    sentencaSQL.execute(sqlCriarTblTiposCaixa);
                    sentencaSQL.close();

                } catch (Exception e3)
                {
                    throw e3;
                }

                // populamos a tabela de tipos de caixa com os valores padrão
                String sqlPopularTblTiposCaixa = "INSERT INTO tipos_caixa(id, nome, status) " +
                        "VALUES(?, ?, ?)";

                try
                {
                    PreparedStatement prepSentSQL = conexao.prepareStatement(sqlPopularTblTiposCaixa);

                    prepSentSQL.setInt(1, 1);
                    prepSentSQL.setString(2, "kg");
                    prepSentSQL.setString(3, "a");
                    prepSentSQL.execute();
                    prepSentSQL.setInt(1, 2);
                    prepSentSQL.setString(2, "unidade");
                    prepSentSQL.execute();
                    prepSentSQL.close();

                } catch (Exception e3)
                {
                    throw e3;
                }
            }
        }
        // se não ocorrer exceção, a tabela já existe e nada fazemos
    }

    /**
     * Cria (se necessário) a tabela tipos_caixa. Caso ela não exista, além de ser criada é populada
     * com seus dados iniciais.
     */
    private void tblQtdesCaixa() throws Exception
    {
        Statement sentencaSQL = conexao.createStatement();

        try
        {
            String sqlTblExiste = "UPDATE qtdes_caixa SET " +
                    "id = 0, qtde = 20, status = 'a' " +
                    "WHERE id = -1";

            sentencaSQL.execute(sqlTblExiste);

        } catch (Exception e)
        {
            SQLException sqle;

            try
            {
                sqle = (SQLException)e;
            }
            catch (Exception e2)
            {
                throw e2;
            }

            String erro = sqle.getSQLState();

            if (erro.equals("42X05"))
            {
                // a tabela não existe; por isso, a criamos
                String sqlCriarTblQtdesCaixa = "CREATE TABLE qtdes_caixa" +
                "(" +
                "id INT NOT NULL, " +
                "qtde INT NOT NULL, " +
                "status CHAR NOT NULL, " +
                "PRIMARY KEY(id)" +
                ")";

                try
                {
                    sentencaSQL.execute(sqlCriarTblQtdesCaixa);
                    sentencaSQL.close();

                } catch (Exception e3)
                {
                    throw e3;
                }

                // populamos a tabela de quantidades por caixa com os valores padrão
                String sqlPopularTblQtdesCaixa = "INSERT INTO qtdes_caixa(id, qtde, status) " +
                        "VALUES(?, ?, ?)";

                try
                {
                    PreparedStatement prepSentSQL = conexao.prepareStatement(sqlPopularTblQtdesCaixa);

                    prepSentSQL.setInt(1, 1);
                    prepSentSQL.setInt(2, 12);
                    prepSentSQL.setString(3, "a");
                    prepSentSQL.execute();
                    prepSentSQL.setInt(1, 2);
                    prepSentSQL.setInt(2, 18);
                    prepSentSQL.execute();
                    prepSentSQL.setInt(1, 3);
                    prepSentSQL.setInt(2, 20);
                    prepSentSQL.execute();
                    prepSentSQL.setInt(1, 4);
                    prepSentSQL.setInt(2, 24);
                    prepSentSQL.execute();
                    prepSentSQL.close();

                } catch (Exception e3)
                {
                    throw e3;
                }
            }
        }
        // se não ocorrer exceção, a tabela já existe e nada fazemos
    }
    
    /**
     * Cria (se necessário) a tabela responsaveis_col. Caso ela não exista, além de ser criada é populada
     * com seus dados iniciais.
     */
    private void tblResponsaveisCol() throws Exception
    {
        Statement sentencaSQL = conexao.createStatement();

        try
        {
            String sqlTblExiste = "UPDATE responsaveis_col SET " +
                    "id = 0, nome = 'teste', status = 'a' " +
                    "WHERE id = -1";

            sentencaSQL.execute(sqlTblExiste);

        } catch (Exception e)
        {
            SQLException sqle;

            try
            {
                sqle = (SQLException)e;
            }
            catch (Exception e2)
            {
                throw e2;
            }

            String erro = sqle.getSQLState();

            if (erro.equals("42X05"))
            {
                // a tabela não existe; por isso, a criamos
                String sqlCriarTblResponsaveisCol = "CREATE TABLE responsaveis_col" +
                "(" +
                "id INT NOT NULL, " +
                "nome VARCHAR(50) NOT NULL, " +
                "status CHAR NOT NULL, " +
                "PRIMARY KEY(id)" +
                ")";

                try
                {
                    sentencaSQL.execute(sqlCriarTblResponsaveisCol);
                    sentencaSQL.close();

                } catch (Exception e3)
                {
                    throw e3;
                }

                // populamos a tabela de responsáveis pelas coletas com os valores padrão
                String sqlPopularTblResponsaveisCol = "INSERT INTO responsaveis_col(id, nome, status) " +
                        "VALUES(?, ?, ?)";

                try
                {
                    PreparedStatement prepSentSQL = conexao.prepareStatement(sqlPopularTblResponsaveisCol);

                    prepSentSQL.setInt(1, 2);
                    prepSentSQL.setString(2, "Damares");
                    prepSentSQL.setString(3, "a");
                    prepSentSQL.execute();
                    prepSentSQL.setInt(1, 3);
                    prepSentSQL.setString(2, "Elaine Lopes");
                    prepSentSQL.execute();
                    prepSentSQL.setInt(1, 4);
                    prepSentSQL.setString(2, "Eliane de Jesus");
                    prepSentSQL.execute();
                    prepSentSQL.setInt(1, 5);
                    prepSentSQL.setString(2, "Elizabeth Akemi Nakamura");
                    prepSentSQL.execute();
                    prepSentSQL.setInt(1, 6);
                    prepSentSQL.setString(2, "Ivair Donizeti de Oliveira");
                    prepSentSQL.execute();
                    prepSentSQL.setInt(1, 7);
                    prepSentSQL.setString(2, "Mariana Fraga Soares Muçouçah");
                    prepSentSQL.execute();
                    prepSentSQL.setInt(1, 8);
                    prepSentSQL.setString(2, "Paulo Roberto de Oliveira");
                    prepSentSQL.execute();
                    prepSentSQL.setInt(1, 9);
                    prepSentSQL.setString(2, "Sheila Borges");
                    prepSentSQL.execute();
                    prepSentSQL.setInt(1, 10);
                    prepSentSQL.setString(2, "Walter Eclache");
                    prepSentSQL.execute();
                    prepSentSQL.setInt(1, 11);
                    prepSentSQL.setString(2, "Wlauton Odeino de Melo");
                    prepSentSQL.execute();
                    prepSentSQL.close();

                } catch (Exception e3)
                {
                    throw e3;
                }
            }
        }
        // se não ocorrer exceção, a tabela já existe e nada fazemos
    }

    /**
     * Cria (se necessário) a tabela tabulacoes_pen (tabela de tabulações pendentes, ou seja, tabulações que ainda
     * não foram enviadas ao servidor).
     */
    private void tblTabulacoesPen() throws Exception
    {
        Statement sentencaSQL = conexao.createStatement();

        try
        {
            String sqlTblExiste = "UPDATE tabulacoes_pen SET " +
                    "id = 0, id_produto = 0, id_entreposto = 0, id_classific = 0, id_tipo_caixa = 0, " +
                    "id_qtde_caixa = 0, id_resp_col = 0, id_resp_col2 = 0, data_col = '2011-06-09' " +
                    "WHERE id = -1";

            sentencaSQL.execute(sqlTblExiste);

        } catch (Exception e)
        {
            SQLException sqle;

            try
            {
                sqle = (SQLException)e;
            }
            catch (Exception e2)
            {
                throw e2;
            }

            String erro = sqle.getSQLState();

            if (erro.equals("42X05"))
            {
                // a tabela não existe; por isso, a criamos
                String sqlCriarTblTabulacoesPen = "CREATE TABLE tabulacoes_pen" +
                    "(" +
                    "id INT NOT NULL GENERATED ALWAYS AS IDENTITY, " +
                    "id_produto INT NOT NULL, " +
                    "id_entreposto INT NOT NULL, " +
                    "id_classific INT NOT NULL, " +
                    "id_tipo_caixa INT NOT NULL, " +
                    "id_qtde_caixa INT NOT NULL, " +
                    "id_resp_col INT NOT NULL, " +
                    "id_resp_col2 INT, " +
                    "data_col DATE NOT NULL, " +
                    "PRIMARY KEY(id)" +
                    ")";

                try
                {
                    sentencaSQL.execute(sqlCriarTblTabulacoesPen);
                    sentencaSQL.close();

                } catch (Exception e3)
                {
                    throw e3;
                }
            }
        }
        // se não ocorrer exceção, a tabela já existe e nada fazemos
    }

    /**
     * Cria (se necessário) a tabela precos (tabela que relaciona preços e tabulações).
     */
    private void tblPrecos() throws Exception
    {
        Statement sentencaSQL = conexao.createStatement();

        try
        {
            String sqlTblExiste = "UPDATE precos SET " +
                    "id = 0, id_tabulacao = 0, valor_caixa = 00.00, valor_unidade = 00.00 " +
                    "WHERE id = -1";

            sentencaSQL.execute(sqlTblExiste);

        } catch (Exception e)
        {
            SQLException sqle;

            try
            {
                sqle = (SQLException)e;
            }
            catch (Exception e2)
            {
                throw e2;
            }

            String erro = sqle.getSQLState();

            if (erro.equals("42X05"))
            {
                // a tabela não existe; por isso, a criamos
                String sqlCriarTblPrecos = "CREATE TABLE precos" +
                    "(" +
                    "id INT NOT NULL GENERATED ALWAYS AS IDENTITY, " +
                    "id_tabulacao INT NOT NULL, " +
                    "valor_caixa REAL NOT NULL, " +
                    "valor_unidade REAL NOT NULL, " +
                    "PRIMARY KEY(id)" +
                    ")";

                try
                {
                    sentencaSQL.execute(sqlCriarTblPrecos);
                    sentencaSQL.close();

                } catch (Exception e3)
                {
                    throw e3;
                }
            }
        }
        // se não ocorrer exceção, a tabela já existe e nada fazemos
    }

    /**
     * Cria (se necessário) a tabela estatisticas (tabela que relaciona um conjunto de estatísticas
     * a uma determinada tabulação).
     */
    private void tblEstatisticas() throws Exception
    {
        Statement sentencaSQL = conexao.createStatement();

        try
        {
            String sqlTblExiste = "UPDATE estatisticas SET " +
                    "id = 0, id_tabulacao = 0, preco_max_c = 0.00, preco_max_u = 0.00, preco_min_c = 0.00, " +
                    "preco_min_u = 0.00, media_caixa = 0.00, media_unidade = 0.00, moda_caixa = 0.00, moda_unidade = 0.00, " +
                    "mediana_caixa = 0.00, mediana_unidade = 0.00 " +
                    "WHERE id = -1";

            sentencaSQL.execute(sqlTblExiste);

        } catch (Exception e)
        {
            SQLException sqle;

            try
            {
                sqle = (SQLException)e;
            }
            catch (Exception e2)
            {
                throw e2;
            }

            String erro = sqle.getSQLState();

            if (erro.equals("42X05"))
            {
                // a tabela não existe; por isso, a criamos
                String sqlCriarTblEstatisticas = "CREATE TABLE estatisticas" +
                    "(" +
                    "id INT NOT NULL GENERATED ALWAYS AS IDENTITY, " +
                    "id_tabulacao INT NOT NULL, " +
                    "preco_max_c REAL NOT NULL, " +
                    "preco_max_u REAL NOT NULL, " +
                    "preco_min_c REAL NOT NULL, " +
                    "preco_min_u REAL NOT NULL, " +
                    "media_caixa REAL NOT NULL, " +
                    "media_unidade REAL NOT NULL, " +
                    "moda_caixa REAL NOT NULL, " +
                    "moda_unidade REAL NOT NULL, " +
                    "mediana_caixa REAL NOT NULL, " +
                    "mediana_unidade REAL NOT NULL, " +
                    "PRIMARY KEY(id)" +
                    ")";

                try
                {
                    sentencaSQL.execute(sqlCriarTblEstatisticas);
                    sentencaSQL.close();

                } catch (Exception e3)
                {
                    throw e3;
                }
            }
        }
        // se não ocorrer exceção, a tabela já existe e nada fazemos
    }
}
